/*----- enchant.jgz.init.js -----*/
/**
 * enchant.jgz.js v0.0.4(2011/11/16)
 * enchant.js extention for JapanGamingZone
 * Dual licensed under the MIT or GPL Version 3 licenses
 * @requires enchant.js v0.4.0 or later
 */
"use strict";
/**
 * ライブラリで使用する画像のパス
 */
var LIB_IMAGE_PATH = '../js_lib/';
/**
 * ライブラリで使用するサウンドのパス
 */
var LIB_SOUND_PATH = '../js_lib/';
/**
 *
 */
enchant.JGZ = {
    assets: [
        LIB_IMAGE_PATH + 'pic_load.gif',
        LIB_IMAGE_PATH + 'bg_dialog.png',
        LIB_IMAGE_PATH + 'bomb.png',
        LIB_SOUND_PATH + 'bomb.wav',
    ]
};
/*----- enchant.jgz.label.js -----*/
/**
 * @scope enchant.JGZ.Label.prototype
 */
enchant.JGZ.Label = enchant.Class.create(enchant.Label, {
  /**
   * Label拡張
   * @constructs
   * @param {Object}  opt x: X座標, y: Y座標, font: フォント指定, color: カラー指定, text: 表示したい文字列.
   */
  initialize : function(opt) {
    enchant.Label.call(this);
    
    /**
     * widthを初期化
     */
    this.width = 0;
    /**
     * X座標
     * @type {Number}
     */
    this.x      = opt.x;
    /**
     * Y座標
     * @type {Number}
     */
    this.y      = opt.y;
    /**
     * フォント指定文字列
     * @type {String}
     */
    this.font   = opt.font;
    /**
     * カラーコードまたはRGB値
     * @type {String}
     */
    this.color  = opt.color;
    /**
     * 表示文字列
     * @type {String}
     */
    this.text   = opt.text;
  }
});
/*----- enchant.jgz.mathposition.js -----*/
/**
 * @scope enchant.JGZ.MathPosition.prototype
 */
enchant.JGZ.MathPosition = enchant.Class.create({
  /**
   * オブジェクトの中のポジションを計算するクラス
   * @constructs
   */
  initialize : function() {
    this.x = this.y = 0;
  },

  /**
   * 中心座標を計算してx,yにセット
   * @param {Object} opt {x: X座標, y: Y座標, renderPosition: 表示位置の指定}
   */
  setCenter : function(opt) {
    var tw  = Math.floor((opt.targetW / 2) + opt.targetX);
    var w   = Math.floor(opt.selfW / 2);
    this.x  = (tw - w) <= 0 ? 0 : tw - w;

    var th  = Math.floor((opt.targetH / 2) + opt.targetY);
    var h   = Math.floor(opt.selfH / 2);
    this.y  = (th - h) <= 0 ? 0 : th - h;
  }
});
/*----- enchant.jgz.resource.js -----*/
/**
 * @scope enchant.JGZ.Resource.prototype
 */
enchant.JGZ.Resource = enchant.Class.create({
  /**
   * リソースのpreloadとインスタンス化を行う
   * @constructs
   * @param {Array} sources リソースの配列.
   */
  initialize : function(sources) {
    var game      = enchant.Game.instance;
    this.sources  = sources;
    this._instance= {};

    for(var idx in sources) {
      game.preload(sources[idx]);
    }

  },
  /**
   * 後からでもリソースを個別に追加可能
   * @param {String}  idx
   * @param {String}  source
   */
  setSource : function(idx, source) {
    var game          = enchant.Game.instance;
    this.sources[idx] = source;            
    game.preload(source);
  },
  /**
   * 全てのリソースをインスタンス化し読み込む
   */
  readAllResource : function() {
    var game    = enchant.Game.instance;
    var sources = this.sources;
    for(var idx in sources) {
      this._instance[idx] = game.assets[sources[idx]];
    }
  }
});
/**
 * @scope enchant.JGZ.Image.prototype
 */
enchant.JGZ.Images = enchant.Class.create(enchant.JGZ.Resource, {
  /**
   * イメージリソースを管理する
   * sourcesは配列
   * {
   *    "success" : "images/card1.jpg",
   *    "false"   : "images/card2.jpg",
   * }
   * @constructs
   * @param {Array} sources
   */
  initialize : function(sources) {
    enchant.JGZ.Resource.call(this, sources);
  },
  /**
   * インデックスを指定してリソースを呼び出す
   * @param {String}  idx
   */
  read : function(idx) {
    return this._instance[idx];
  },
  /**
   * 登録されている画像リソースからスプライトイメージを作成する
   * w : width
   * h : height
   * i : index
   * x : x
   * y : y
   * @param {Object}  opt
   */
  sprite : function(opt) {
    var s   = new enchant.JGZ.SpriteEx(opt.w, opt.h);
    s.x     = opt.x;
    s.y     = opt.y;
    s.image = this._instance[opt.i];
    return s;
  }
});
/**
 * @scope enchant.JGZ.Sound.prototype
 */
enchant.JGZ.Sounds = enchant.Class.create(enchant.JGZ.Resource, {
  /**
   * サウンドリソースを管理する
   * sourcesは配列
   * {
   *    "success" : "sounds/success.wav",
   *    "false"   : "sounds/false.wav",
   * }
   * @constructs
   * @param {Array} sources 
   */
  initialize : function(sources) {
    enchant.JGZ.Resource.call(this, sources);
  },
  /**
   * サウンドを再生する
   * @param {String}  idx
   */
  play : function(idx) {
    this._instance[idx].play();
  },
  /**
   * サウンドを停止する
   * @param {String}  idx
   */
  stop : function(idx) {
    this._instance[idx].stop();
  }
});
/*----- enchant.jgz.array.js -----*/
/**
 * @scope enchant.JGZ.ArrayEx.prototype
 */
enchant.JGZ.ArrayEx = enchant.Class.create(Array, {
  /**
   * 配列管理
   * @constructs
   * @param  {Array} arr
   */
  initialize : function(arr) {
    this._arr = new Array();
    if (arr !== undefined) {
      this._arr = arr;
    }
  }, 
  /**
   * 配列リストのシャッフルを行う
   */
  shuffle : function() {
    var i = this._arr.length;
    while (--i) {
        var j = Math.floor( Math.random() * (i + 1)) ;
        if (i == j) continue;
        var k = this._arr[i];
        this._arr[i] = this._arr[j];
        this._arr[j] = k;
    }
  },
  arr : {
    get: function() {
      return this._arr;      
    },
    set: function() {
    }
  }
});
/*----- enchant.jgz.object.js -----*/
/**
 * @scope enchant.JGZ.ObjectEx.prototype
 */
enchant.JGZ.ObjectEx = enchant.Class.create(Object, {
  /**
   * オブジェクト操作
   * @constructs
   * @param {Object}  obj
   */
  initialize : function(obj){
    this._obj = new Object();
    if (obj !== undefined) {
      this._obj = obj;
    }
  },
  /**
   * 元のオブジェクトを破壊しない
   * @param {Object}  obj
   */
  concat : function(obj) {
    for (var idx in obj) {
      if (this._obj[idx] === undefined) {
        this._obj[idx] = obj[idx];
      }
    }
    return this._obj;
  },
  /**
   * 元のオブジェクトを上書する
   * @param {Object}  obj
   */
  apply : function(obj) {
    for (var idx in obj) {
      this._obj[idx] = obj[idx];
    }
    return this._obj;
  },
  o : {
    get: function() {
      return this._obj;      
    },
    set: function(obj) {
      this._obj = obj;
    }
  }
});
/*----- enchant.jgz.figure.js -----*/
/**
 * @scope enchant.JGZ.Figure.prototype
 */
enchant.JGZ.Figure = enchant.Class.create(enchant.JGZ.SpriteEx, {
  /**
   * 様々な図形Spriteを作り出す
   * @constructs
   * @param {Object} opt  opt.x: X座標, opt.y: Y座標
   */
  initialize : function(opt) {
    this._opt   = opt;
    var s       = this._generate(opt);

    enchant.JGZ.SpriteEx.call(this, s.width, s.height);
    this.image  = s;
    this.x      = opt.x;
    this.y      = opt.y;
  },
  /**
   * 各種図形生成メソッド
   */
  _generate : function(opt) {
  },
  /**
   * 図形の色を変更する
   * @param {String} color 色指定
   */
  changeColor : function(color) {
    this._opt.color = color;              
    this.image      = this._generate(this._opt);
  },
  o : {
    set: function() {
    },
    get: function() {
      return this._opt;     
    }
  }
});
/**
 * @scope enchant.JGZ.Square.prototype
 */
enchant.JGZ.Square = enchant.Class.create(enchant.JGZ.Figure, {
  /**
   * 四角形を作り出す
   * @constructs
   * @param {Object} opt
   */
  initialize : function(opt) {
    enchant.JGZ.Figure.call(this, opt);
  },
  /**
   * 四角形実生成部分
   * @param {Object} opt  opt.w: width, opt.h: height, opt.color: 色指定
   */
  _generate : function(opt) {
    var s = new Surface(opt.w, opt.h);
    s.context.fillStyle = opt.color;
    s.context.fillRect(0, 0, opt.w, opt.h);
    return s;           
  }
});
/**
 * @scope enchant.JGZ.Arc.prototype
 */
enchant.JGZ.Arc = enchant.Class.create(enchant.JGZ.Figure, {
  /**
   * 円を作り出す
   * @constructs
   * @param {Object} opt
   */
  initialize : function(opt) {
    enchant.JGZ.Figure.call(this, opt);
  },
  /**
   * 円実生成部分
   * @param {Object} opt  opt.x: X座標, opt.y: Y座標, opt.radius: radius, opt.color: 色指定
   */
  _generate : function(opt) {
    var s = new Surface(opt.radius*2, opt.radius*2);
    s.context.fillStyle = opt.color;
    s.context.beginPath();
    s.context.arc(opt.radius, opt.radius, opt.radius, 0, Math.PI*2, false);
    s.context.fill();
    return s;           
  },
  radius : {
    set: function() {
    },
    get: function() {
      return this._opt.radius;     
    }
  }

});
/*----- enchant.jgz.sprite.js -----*/
/**
 * @scope enchant.JGZ.SpriteEx.prototype
 * 基本的にアニメーション等を実装
 */
enchant.JGZ.SpriteEx = enchant.Class.create(enchant.Sprite, {
  /**
   * Spriteの拡張実装
   * アニメーション等を行えるようにする
   * @constructs
   * @param {Number} w width
   * @param {Number} w height
   */
  initialize : function(w, h) {
    Sprite.call(this, w, h);
    this._Queue       = [];
    this._QueueParams = [];
    this._QueueAll    = false;
  },

  /**
   * オブジェクト衝突時の進行方向を計算
   */
  mathMovement : function(target) {
    var that = this;
    var cx = that.cx;
    var cy = that.cy;

    //左上に衝突
    if ((target.x) < (that.x + cx) &&
        (target.y + cy) < (that.y + cy) &&
        that.angle === true) {
      return {
        "mx" : target.speed * -1,
        "my" : target.speed * -1
      };
    }

    //右上に衝突
    if ((target.x + cx) > (that.x + that.width - cx) &&
        (target.y + cy) < (that.y + cy) &&
        that.angle === true) {
      return {
        "mx" : target.speed * 1,
        "my" : target.speed * -1
      };
    }

    //左下に衝突
    if ((target.x) < (that.x + cx) &&
        (target.y - cy) > (that.y + cy) &&
        that.angle === true) {
      return {
        "mx" : target.speed * -1,
        "my" : target.speed * 1
      };
    }

    //右下に衝突
    if ((target.x + cx) > (that.x + that.width - cx) &&
        (target.y - cy) > (that.y + cy) &&
        that.angle === true) {
      return {
        "mx" : target.speed * 1,
        "my" : target.speed * 1
      };
    }

    //左に衝突
    if ((target.x) < (that.x + cx) && 
        ((target.y + (target.radius / 2))) > that.y &&
        ((target.y + (target.radius / 2))) < (that.y + that.height)) {
      return {
        "mx" : target.speed * -1,
        "my" : target.speed * (target.my < 1 ? -1 : 1)
      };
    }

    //右に衝突
    if ((target.x + cx) > (that.x + that.width - cx) &&
        ((target.y + (target.radius / 2))) > that.y &&
        ((target.y + (target.radius / 2))) < (that.y + that.height)) {
      return {
        "mx" : target.speed * 1,
        "my" : target.speed * (target.my < 1 ? -1 : 1)
      };
    }

    //上に衝突
    if ((target.y) < (that.y + cy)) {
      return {
        "mx" : target.speed * (target.mx < 1 ? -1 : 1),
        "my" : target.speed * -1
      };
    }

    //下に衝突
    if ((target.y - cy) > (that.y + cy)) {
      return {
        "mx" : target.speed * (target.mx < 1 ? -1 : 1),
        "my" : target.speed * 1
      };
    }

    return false;

  },
  
  /**
   * テキストを画像に重ねる
   */
  text : {
    get: function() {
    },
    /**
     * @param {Object} opt {font: フォント, color: カラー, x: X座標, y: Y座標}
     */
    set: function(opt) {
      if (this._o === undefined) {
        this._o = function(obj) {
          var f = function() {};
          f.prototype = obj;
          return new f();
        }(this.image);
      }

      var s = new enchant.Surface(this.width, this.height);
      s.draw(this._o);
      s.context.font        = opt.font !== undefined ? opt.font : '12px Arial';
      s.context.strokeStyle = opt.color !== undefined ? opt.color : '#000000';
      s.context.strokeText(opt.text, opt.x, opt.y);
      this.image = s;
    }
  },
  /**
   * キューにアニメーションを追加する
   */
  addQueue: function(func) {
    this._QueueAll = false;
    this._Queue.push(func);
  },
  /**
   * キューを実行する
   */
  runQueue: function() {
    var i     = this._Queue.length;
    var func  = this._Queue.pop();

    if (func !== undefined) {
      eval("this." + func + "()");
    }

    return this;
  },
  /**
   * キューを全て実行する
   */
  runAllQueue: function() {
    var that  = this;
    var len   = this._Queue.length;
    this._QueueAll = true;
    this.runQueue();
  },
  /**
   * 左右に揺れるアニメーション
   * @param {Object} opt {}
   */
  roll: function(opt) {
    var that = this;
    var game = enchant.Game.instance;
    /**
     * アニメーションを行う前のX座標
     * @type {Number}
     */
    this.ox      = this.x;
    /**
     * アニメーションを行う長さ
     * @type {Number}
     */
    this.w       = 0;
    /**
     * フラグ
     * @type {Number}
     */
    this.f       = 1;
    /**
     * オブジェクトのステータス
     * @type {Number}
     */
    this.status  = 0;
    
    var timerID = setInterval(function(){that._roll(timerID)}, 10);

    return this;
  },
  /**
   * アニメーション本体ロジック
   */
  _roll: function(timerID) {
    var game  = enchant.Game.instance;
    var count = parseInt(game.frame % game.fps);

    if (count != 0) {
      if (this.f >= 1) {
        this.x  = this.ox;
        this.x += 10;
      } else {
        this.x  = this.ox;
        this.x -= 10; 
      }
      this.f = this.f * (-1);
      this.w++;

      if (this.w >= 30) {
        clearInterval(timerID);
        this.x = this.ox;
        if (this._QueueAll) {
          this.runQueue();
        }
      }
    }
  },
  /**
   * 落ちる動作(ブロック)
   * @param {Object}  opt {opt.opacity: (boolean) 透過していくかどうか}
   */
  fall: function(opt) {
    var that        = this;
    this.waitMax    = 0;
    this.waitCount  = 0;
    this.status     = 0;

    var timerID = setInterval(function(){that._fall(timerID, opt)}, 10);

    return this;
  },
  /**
   * 落ちる動作本体ロジック
   */
  _fall: function(timerID, opt) {
    var game        = enchant.Game.instance;
    var scene       = game.currentScene;
    var speed       = 1;
    if (opt !== undefined && opt.speed !== undefined) {
      speed = parseInt(opt.speed);
    }

    var o           = speed / (game.height - this.y);
    var count       = parseInt(game.frame % game.fps);

    if (this.waitCount >= this.waitMax) {
      if (opt !== undefined && opt.opacity === true) {
        this.opacity -= o;
      }
      this.y += speed;
      this.waitCount = 0; 
    } else {
      this.waitCount++; 
    }

    if (this.y >= game.height) {
      clearInterval(timerID);
      scene.removeChild(this);

      if (this._QueueAll) {
        this.runQueue();
      }
    }
        
  },
  /**
   * 爆発するアニメーション
   * @param {Object}  obj {opt.scale: 爆発エフェクトの大きさ　デフォルトは1, opt.sound: (boolean) 音を再生するかどうか デフォルトでは再生する}
   */
  bomb: function(opt) {
    var that        = this;
    var game        = enchant.Game.instance;
    var scene       = game.currentScene;
    this.sound      = game.assets[LIB_SOUND_PATH + 'bomb.wav'];
    this.image      = game.assets[LIB_IMAGE_PATH + 'bomb.png'];
    this.width      = 16;
    this.height     = 16;
    this.scaleX     = this.scaleY = (opt !== undefined) ? opt.scale : 1;
    this.waitMax    = 0;
    this.waitCount  = 0;
    this.bombMax    = 0;
    this.bombCount  = 0;
    this.status     = 0;
    this.addEventListener(enchant.Event.ENTER_FRAME, function(){
      switch (this.status) {
      case 0: 
        if (this.waitCount >= this.waitMax) {
          this.frame++;
          this.waitCount = 0; 
        } else {
          this.waitCount++; 
        }

        if (this.frame >= 5) {
          this.bombCount++; 
        }
        if (this.bombCount >= this.bombMax) {
          if (opt === undefined || opt.sound === true) {
            this.sound.play();
          }
          this.status = 1; 
        }
        break;
      case 1:
        this.visible = false;
        scene.removeChild(this);
        break;
      }
    });
    return this;
  },
  /**
   * 回転するような動作（カードとか）
   * @param {Object} opt , opt.scaleX: アニメーション後scaleXを変更する場合{opt.frame: アニメーション後フレームを変更する場合はフレームの番号, opt.scaleY: アニメーション後scaleYを変更する場合}
   */
  turn: function(opt) {
    var that      = this;
    var game      = enchant.Game.instance;
    var scene     = game.currentScene;
    scene.flip    = 0;
    scene.status  = 0;
    scene.addEventListener(enchant.Event.ENTER_FRAME, function(){
      switch (this.status) {
        case 0:
          if (this.flip < 3) {
            that.scaleX += 0.5 * (Math.floor(this.flip /2) * 2 - 1);
            this.flip = 0;
            this.status = 1;
          }
          this.flip++;
          break;
        case 1:
          that.scaleX = opt.scaleX === undefined ? 1 : opt.scaleX;
          that.scaleY = opt.scaleY === undefined ? 1 : opt.scaleY;
          that.frame = opt.frame === undefined ? 1 : opt.frame;
          break;
      }
    });
    return this;
  },
});
/*----- enchant.jgz.urlparser.js -----*/
/**
 * @scope enchant.JGZ.URLParser.prototype
 */
enchant.JGZ.URLParser = enchant.Class.create({
  /**
   * URLパーサ
   * @constructs
   * @param {String}  url URL
   */
  initialize : function(url) {
    this.url      = url;
    this.urlParam = url.substring(1);
    this._params  = {};
  },
  /**
   * @description パース処理
   */
  _parse: function() {
    var that    = this;
    var params  = {};
    var pairs   = that.urlParam.split('&');
    var len     = pairs.length;

    for (var i=0;i<len;i++) {
      var kv = pairs[i].split('=');
      params[kv[0]] = kv[1];
    }
    
    this._params = params;
  },
  /**
   * @description パラメータ
   */
  params: {
    get: function() {
      return this._params;
    },
    set: function() {
    }
  }
});
/*----- enchant.jgz.storage.js -----*/
/**
 * @scope enchant.JGZ.Storage.prototype
 */
enchant.JGZ.Storage = enchant.Class.create({
  /**
   * 初期化
   * @constructs
   */
  initialize : function(key_name) {
    this._storage = new enchant.JGZ.ObjectEx();
    this._LC_KEY  = 'LC_STORAGE_' + key_name;
    var storageValue = localStorage.getItem(this._LC_KEY);
    if (storageValue != null && storageValue != undefined && storageValue != 'undefined') {
      this._storage.apply(JSON.parse(storageValue));
    }
  }, 
  /**
   * 値を保存
   */
  set : function(key, value) {
    var obj = new Object();
    obj[key] = value;
    this._storage.apply(obj);
    this._set();
  },
  _set : function() {
    var str = JSON.stringify(this._storage.o);
    localStorage.setItem(this._LC_KEY, str);
  },
  /**
   * 値を取得する
   */
  get : function(key) {
    var str = localStorage.getItem(this._LC_KEY);
    if (str == null || str == undefined || str == 'undefined') {
      return false;
    }
    var json_str = JSON.parse(str);
    if (json_str[key] !== undefined) {
      return json_str[key];
    }
    return false;
  },
  /**
   * 値をクリアする
   */
  clear : function (key) {
    var str = localStorage.getItem(this._LC_KEY);
    var json_str = JSON.parse(str);
    if (json_str[key] !== undefined) {
      delete json_str[key];
      this._storage.o = json_str;
      this._set();
    }
    return true;
  },
  /**
   * 全ての値をクリア
   */
  destroy : function() {
    this._storage = new enchant.JGZ.ObjectEx();
    localStorage.setItem(this._LC_KEY);
  },
  /**
   * 全てのローカルストレージをクリア
   * このオブジェクト以外のストレージも全てクリアされますので注意して使ってください
   */
  destroyAll : function() {
    localStorage.clear();
  }

});
/*----- enchant.jgz.timer.js -----*/
/**
 * @scope enchant.JGZ.Timer.prototype
 */
enchant.JGZ.Timer = enchant.Class.create(enchant.JGZ.Label, {
  /**
   * タイマーの作成・更新等を行う
   * @constructs
   * @param {Object}  opt {time: 初期タイム, text: 初期テキスト}
   */
  initialize : function(opt) {
    opt.sec       = opt.time;
    this._opt     = opt;
    opt.text      = this.manipulateText(opt.text, opt);
    this._obj     = enchant.JGZ.Label.call(this, opt);
    this._nTimer  = 0;
  },
  /**
   * タイマーアップデート
   */
  update : function() {
    var g         = enchant.Game.instance;
    var p         = parseInt(g.frame % g.fps);

    if (p === 0) {
      this._nTimer++; 
    }

    var scale     = (60 / parseInt(g.fps));
    var msec      = 60 - (Math.floor(g.frame % g.fps) * scale);
    var t         = this._opt.time - this._nTimer;
    var min       = parseInt(t / 60);
    var sec       = parseInt(t % 60);
    msec = ((min <= 0) && (sec <= 0)) ? 0 : msec;
    var time      = ("0" + min).slice(-2) + '.' + ("0" + sec).slice(-2) + '.' + ("0" + msec).slice(-2);
    if (this._opt.render !== undefined) {
      time = t; 
    }
    this.text     = this.manipulateText(time, this._opt);
    this._opt.sec = t;
  },
  /**
   * タイマーテキストを加工
   */
  manipulateText : function(text, opt) {
    if (opt.prefix !== undefined) {
      text = opt.prefix + text; 
    }
    if (opt.suffix !== undefined) {
      text = text + opt.suffix; 
    }
    return text;
  },

  sec : {
    get: function() {
      return this._opt.sec;      
    },
    set: function() {
    }
  },

  options : {
    get: function() {
      return this._opt;      
    },
    set: function() {
    }
  }
});
/*----- enchant.jgz.loading.js -----*/
/**
 * @scope enchant.JGZ.Loading.prototype
 */
enchant.JGZ.Loading = enchant.Class.create(enchant.Sprite, {
  /**
   * Loading画像の表示を行う
   * @constructs
   * @param {Number}  x X座標
   * @param {Number}  y Y座標
   */
  initialize : function(x, y) {
    Sprite.call(this, 100, 100);

    var game    = enchant.Game.instance;
    this.image  = game.assets[LIB_IMAGE_PATH + 'pic_load.gif'];
    this.x      = x;
    this.y      = y;
  }
});
/*----- enchant.jgz.scene.js -----*/
/**
 * @scope enchant.JGZ.SceneManage.prototype
 */
enchant.JGZ.SceneManage = enchant.Class.create({
  /**
   * 初期化
   * @constructs
   */
  initialize : function() {
    this._scene       = new enchant.JGZ.ObjectEx();
    this._currentKey  = '';
    this._prevKey     = '';
    this._nextKey     = '';
  }, 
  /**
   * 現在のシーン
   */
  currentScene: {
    get: function() {
      return this._scene[this._currentKey];
    },
    set: function() {
         
    }
  },
  /**
   * シーンの追加
   */
  addScene : function(sceneKey, scene) {
    this._scene.apply({
      sceneKey : scene 
    });
  },
  /**
   * 次のシーン
   */
  nextScene: {
    get: function() {
      return this._nextScene;     
    },
    set: function(scene) {
      this._nextScene = scene;
    }
  },
  /**
   * 前のシーン
   */
  prevScene: {
             
  },

});
/*----- enchant.jgz.box.js -----*/
/**
 * @scope enchant.JGZ.Dialog.prototype
 */
enchant.JGZ.Box = enchant.Class.create(enchant.Sprite, {
  /**
   * Dialogの表示を行う
   * @constructs
   * @param {Object} opt {x: X座標, y: Y座標, renderPosition: 表示位置の指定}
   */
  initialize : function(opt) {
    Sprite.call(this, 340, 200);

    var game    = enchant.Game.instance;
    this.image  = game.assets[LIB_IMAGE_PATH + 'bg_dialog.png'];

    if (opt.renderPosition !== undefined) {
      switch (opt.renderPosition) {
      case 'center' :
        var position = new enchant.JGZ.MathPosition();
        position.setCenter({
          'type'    : opt.renderPosition,
          'selfW'   : 340,
          'selfH'   : 200,
          'targetW' : game.width,
          'targetH' : game.height,
          'targetX' : 0,
          'targetY' : 0
        });
      }

      this.x = position.x;
      this.y = position.y;
    } else {
      this.x      = opt.x;
      this.y      = opt.y;
    }
  }
});
